package com.javacoo.xservice.base.security.util;

import com.javacoo.xservice.base.security.BASE64Encoder;
import com.javacoo.xservice.base.security.coder.AESCoder;
import com.javacoo.xservice.base.security.coder.DESCoder;

/**
 * 数据加密辅助类(默认编码UTF-8)
 * <p>
 * 说明:
 * </p>
 * <li>基于DES算法的数据加解密</li>
 * @auther DuanYong
 * @since 2017年2月7日下午5:24:49
 */
public final class SecurityUtil {
	private SecurityUtil() {
	}

	/**
	 * 默认算法密钥
	 */
	private static final byte[] ENCRYPT_KEY = { -81, 0, 105, 7, -32, 26, -49, 88 };

	public static final String CHARSET = "UTF-8";
	
	private static final String SEC_KEY = "XrYuB4We";
	
	private static final int ROUNDS = 16;


	/**
	 * 数据解密，算法（DES）
	 *
	 * @param cryptData
	 *            加密数据
	 * @return 解密后的数据
	 */
	public static final String decryptDefaultDes(String cryptData) {
		return decryptDes(cryptData, ENCRYPT_KEY);
	}

	/**
	 * 数据加密，算法（DES）
	 *
	 * @param data
	 *            要进行加密的数据
	 * @return 加密后的数据
	 */
	public static final String encryptDefaultDes(String data) {
		return encryptDes(data, ENCRYPT_KEY);
	}

	/**
	 * 数据解密，算法（DES）
	 * 
	 * @param cryptData
	 *            加密数据
	 * @return 解密后的数据
	 */
	public static final String decryptDes(String cryptData, byte[] key) {
		String decryptedData = null;
		try {
			// 把字符串解码为字节数组，并解密
			decryptedData = new String(DESCoder.decrypt(decryptBASE64(cryptData), key));
		} catch (Exception e) {
			throw new RuntimeException("解密错误，错误信息：", e);
		}
		return decryptedData;
	}
    /**
     * 数据解密，算法（DES）
     *
     * @param cryptData
     *            加密数据
     * @param key
     *            密钥
     * @return 解密后的数据
     */
    public static final String decryptDes(String cryptData, String key) {
        String decryptedData = null;
        try {
            // 把字符串解码为字节数组，并解密
            decryptedData = new String(DESCoder.decrypt(decryptBASE64(cryptData), key.getBytes()));
        } catch (Exception e) {
            throw new RuntimeException("解密错误，错误信息：", e);
        }
        return decryptedData;
    }

	/**
	 * 数据加密，算法（DES）
	 * 
	 * @param data
	 *            要进行加密的数据
	 * @return 加密后的数据
	 */
	public static final String encryptDes(String data, byte[] key) {
		String encryptedData = null;
		try {
			// 加密，并把字节数组编码成字符串
			encryptedData = encryptBASE64(DESCoder.encrypt(data.getBytes(), key));
		} catch (Exception e) {
			throw new RuntimeException("加密错误，错误信息：", e);
		}
		return encryptedData;
	}
    /**
     * 数据加密，算法（DES）
     * 加密算法:Base64(DES(value,secretKey))
     * @param data
     *            要进行加密的数据
     * @param key
     *            密钥
     * @return 加密后的数据
     */
    public static final String encryptDes(String data, String key) {
        String encryptedData = null;
        try {
            // 加密，并把字节数组编码成字符串
            encryptedData = encryptBASE64(DESCoder.encrypt(data.getBytes(), key.getBytes("UTF-8")));
        } catch (Exception e) {
            throw new RuntimeException("加密错误，错误信息：", e);
        }
        return encryptedData;
    }
	/**
	 * BASE64解码
	 * 
	 * @param key
	 * @return
	 * @throws Exception
	 */
	private static final byte[] decryptBASE64(String key) {
		try {
			return new BASE64Encoder().decode(key);
		} catch (Exception e) {
			throw new RuntimeException("解密错误，错误信息：", e);
		}
	}

	/**
	 * BASE64编码
	 * 
	 * @param key
	 * @return
	 * @throws Exception
	 */
	private static final String encryptBASE64(byte[] key) {
		try {
			return new BASE64Encoder().encode(key);
		} catch (Exception e) {
			throw new RuntimeException("加密错误，错误信息：", e);
		}
	}
    /**
     * aes加密
     * <p>说明:</p>
     * <li></li>
     * @author DuanYong
     * @param rawKey 密钥
     * @param data 待加密数据
     * @return 加密后数据
     * @since 2017年11月14日下午7:10:42
     */
	public static byte[] aesEncrypt(byte[] rawKey, String data) {
		return AESCoder.encrypt(rawKey, data);
	}
    /**
     * AES解密
     * <p>说明:</p>
     * <li></li>
     * @author DuanYong
     * @param encrypted 密文
     * @param rawKey 密钥
     * @return 解密后的字符串
     * @since 2017年11月14日下午7:10:16
     */
	public static String aesDecrypt(byte[] encrypted, byte[] rawKey) {
		return AESCoder.decrypt(encrypted, rawKey);
	}

    /**
     * 数据解密，算法（DES）
     *
     * @param cryptData
     *            加密数据
     * @return 解密后的数据
     */
    public static final String decryptDes(String cryptData) {
        return decryptDes(cryptData, ENCRYPT_KEY);
    }

    /**
     * 数据加密，算法（DES）
     *
     * @param data
     *            要进行加密的数据
     * @return 加密后的数据
     */
    public static final String encryptDes(String data) {
        return encryptDes(data, ENCRYPT_KEY);
    }

	public static void main(String[] args) throws Exception {
//		System.out.println(encryptDes("wx",ENCRYPT_KEY));
//		System.out.println(decryptDes("INzvw/3Qc4q=",ENCRYPT_KEY));
//
		System.out.println(encryptDes("MMJrwqjbbwxH8iSW",ENCRYPT_KEY));
		System.out.println(decryptDes("7S9yQ5Pm9/e=",ENCRYPT_KEY));
	}
}
